home *** CD-ROM | disk | FTP | other *** search
/ One Click 14 / OneClick14.iso / Ferramentas / Convert XLS to Pdf / xls2pdf_setup.exe / {app} / lib / pdf_font.ps < prev    next >
Encoding:
Text File  |  2002-11-15  |  39.4 KB  |  1,225 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: pdf_font.ps,v 1.51 2002/11/14 21:22:22 alexcher Exp $
  17. % pdf_font.ps
  18. % PDF font operations.
  19.  
  20. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  21. .currentglobal true .setglobal
  22. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  23. GS_PDF_ProcSet begin
  24. pdfdict begin
  25.  
  26. % We cache the PostScript font in an additional element of the
  27. % font resource dictionary, called PSFont.
  28.  
  29. % ---------------- Encodings ---------------- %
  30.  
  31. /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
  32.  
  33. % Apply a list of differences to an Encoding.
  34. % Note that the differences may cause the array to grow.
  35. /updateencoding {    % <encoding|null> <differences> updateencoding <enc'>
  36.     % Calculate the length of the result.
  37.   % in case the incoming Encoding is null, use .notdefEncoding
  38.   exch dup null eq { pop .notdefEncoding } if
  39.   0 0 3 index {
  40.     dup type /nametype ne { exch pop oforce } { pop 1 add } ifelse
  41.     % Differences list may not be in order, update the largest_index
  42.     % stack: <Differences> <encoding> <largest_index> <at_index>
  43.     2 copy lt { exch pop dup } if    % at_index is new largest
  44.   } forall
  45.   pop 1 index length .max array dup 0 4 -1 roll putinterval
  46.   exch 0 exch {
  47.         % Stack: enc' code element
  48.     dup type /nametype ne
  49.       { exch pop oforce }
  50.       { 3 copy put pop 1 add }
  51.     ifelse
  52.   } forall pop
  53. } bdef
  54.  
  55. % Get the Encoding for a font.
  56. /getencoding        % <base-encoding> <font-resource> getencoding <enc>
  57.  { /Encoding knownoget
  58.     { dup type /nametype eq
  59.        {
  60.          % The published PDF specification says the Encoding name
  61.          % "must be" one of the 3 predefined Encodings, implying
  62.          % that an error should occur if it isn't.  However, Acrobat
  63.          % Reader simply ignores unknown names, and since there are
  64.          % some buggy applications that rely on this, we do the same.
  65.  
  66.          dup dup dup /MacRomanEncoding eq
  67.          exch /MacExpertEncoding eq or 
  68.          exch /WinAnsiEncoding eq or
  69.            { exch pop findencoding
  70.            }
  71.            { pop
  72.            }
  73.          ifelse
  74.        }
  75.        { dup /BaseEncoding knownoget
  76.       { findencoding 3 -1 roll pop exch
  77.       }
  78.      if
  79.      /Differences knownoget { updateencoding } if
  80.        }
  81.       ifelse
  82.     }
  83.    if
  84.  } bdef
  85.  
  86. % Define a font using it's FontName as the key.
  87. % Adjust a font according to the Encoding and Widths in the font resource.
  88. /adjustfont {        % <font-resource> <font> adjustfont <font'>
  89.   getfontencoding
  90.   getfontmetrics 4 -1 roll pop .updatefont { dup /FontName get exch definefont } if
  91. } bind def
  92.  
  93. % Get the (possibly modified) encoding of a font.
  94. /getfontencoding {    % <font-resource> <font> getfontencoding
  95.             %   <font-resource> <font> <Encoding|null>
  96.   1 index /Encoding known {
  97.     dup /Encoding knownoget { 2 index getencoding } { null } ifelse
  98.   } {
  99.     null
  100.   } ifelse
  101. } bdef
  102.  
  103. % Returns true if the current glyph is in the Differences array at
  104. % the specified index value. This is needed because the Widths
  105. % array may map to the same glyph at different positions from the
  106. % Encoding. We want to use the Width that was associated with the
  107. % one specified in the Encoding::Differences list.
  108. /match_in_diff     % <Differences> <index> <glyphname> match_in_diff <bool>
  109. { false 4 1 roll 0 4 -1 roll    % stack: false index glyphname at_index==0 Differences
  110.   { exch 1 index type /nametype ne {
  111.       % stack: false index glyphname Diff_element at_index 
  112.       pop    % Diff_element is new at_index
  113.     } {
  114.       % stack: false index glyphname Diff_element at_index 
  115.       exch 2 index eq {
  116.         % stack: false index glyphname at_index 
  117.     dup 3 index eq {
  118.           true 5 1 roll    % stack: true false index glyphname at_index
  119.           pop exit
  120.         } if
  121.       } if
  122.       1 add        % at_index++ stack: false index glyphname at_index' 
  123.     } ifelse
  124.   } forall
  125.   % stack: true  false index     glyphname
  126.   %  or  : false index glyphname at_index
  127.   pop pop pop
  128. } bdef
  129.  
  130. % Get the metrics of a font, if specified.
  131. /getfontmetrics {    % <font-resource> <font> <Encoding|null> getfontmetrics
  132.             %   <font-resource> <font> <Encoding|null>
  133.             %   <Metrics|null>
  134.   2 index /Widths known {
  135.     dup null eq { pop dup /Encoding get } if
  136.     4 dict begin
  137.       /Encoding exch def
  138.       /Metrics Encoding length dict def
  139.       exch
  140.       dup /Widths oget /Widths exch def
  141.         % Stack: font font-res
  142.         % Note that widths are always based on a 1000-unit
  143.         % character space, but the FontMatrix may specify
  144.         % some other scale factor.  Compensate for this here,
  145.         % by scaling the Widths if necessary.
  146.       0.001 2 index /FontMatrix get 0 get div
  147.         % Stack: font font-res mscale
  148.       1 index /FirstChar oget dup 1 4 index /LastChar oget
  149.        {    % Stack: font font-res mscale first-char index
  150.      Encoding 1 index dup 2 index length ge {
  151.            (   **** Warning: Font Encoding array size is smaller than character range.\n)
  152.            pdfformaterror
  153.        pop pop /.notdef
  154.          } {
  155.        get
  156.      } ifelse
  157.      Widths 2 index 4 index sub dup 2 index length ge {
  158.            (   **** Warning: Font Widths array size is smaller than character range.\n)
  159.            pdfformaterror
  160.            % use MissingWidth if it's available, if not, default to 1000 (full width)
  161.        pop pop 4 index /FontDescriptor knownoget {
  162.          /MissingWidth knownoget not { 1000    } if
  163.        } { 1000 } ifelse
  164.          } {
  165.        get
  166.      } ifelse
  167.          % Stack: font font-res mscale first-char index charname width
  168.      4 index mul
  169.         % The following 'loop' is only context for 'exit'.
  170.      {    
  171.         % Work around a bug in pdfTeX, which can generate Encoding
  172.         % vectors containing nulls :
  173.        1 index null eq { exit } if
  174.         % There is a hack here to deal with encodings where the
  175.         % same character appears more than once, because the Metrics
  176.         % dictionary works by character name, not by character code.
  177.         % We prefer to take (1) non-zero width, and (2) width for 
  178.         % the character name which appears in Differences. If the
  179.         % character name appears in Differences, use the Width that
  180.         % corresponds to the index in differences.
  181.        dup 0 eq { exit } if
  182.        Metrics 2 index .knownget not { 0 } if 0 ne {
  183.          5 index /Encoding knownoget not { exit } if
  184.          dup type /dicttype ne { pop exit } if
  185.          /Differences knownoget not { exit } if
  186.          3 index 3 index //match_in_diff exec not { exit } if
  187.        } if
  188.        2 copy Metrics 3 1 roll put
  189.        exit
  190.      } loop
  191.      pop pop pop
  192.        }
  193.       for pop
  194.         % Now fill in the MissingWidth for any encoded characters
  195.         % that aren't in Metrics already.  Note that built-in
  196.         % fonts may have Widths/FirstChar/LastChar but no
  197.         % FontDescriptor, so we must check for this.
  198.         % Stack: font font-res mscale
  199.       1 index /FontDescriptor knownoget {
  200.     Metrics exch
  201.     /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
  202.     Encoding {
  203.         % Stack: font font-res mscale missing-width metrics charname
  204.         % Work around the abovementioned pdfTeX bug.
  205.       dup null ne {
  206.         2 copy known not { 2 copy 4 index put } if pop
  207.       } {
  208.         pop
  209.       } ifelse
  210.     } forall pop pop pop
  211.       } {
  212.     pop
  213.       } ifelse
  214.     exch Encoding Metrics end
  215.   } {
  216.     null
  217.   } ifelse
  218. } bdef
  219.  
  220. currentdict /match_in_diff undef
  221.  
  222. % ---------------- Descriptors ---------------- %
  223.  
  224. % Partial descriptors for the 14 built-in fonts.  Note that
  225. % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
  226. % object has undergone a subtle change in its meaning which has serious
  227. % consequences for searching with Acrobat:
  228. % In PDF 1.1, the flag meant: Font has StandardEncoding
  229. % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
  230. /standardfontdescriptors mark
  231.   /Courier mark /Flags 16#23 .dicttomark
  232.   /Courier-Oblique 1 index
  233.   /Courier-Bold 1 index
  234.   /Courier-BoldOblique 1 index
  235.   /Helvetica mark /Flags 16#20 .dicttomark
  236.   /Helvetica-Oblique 1 index
  237.   /Helvetica-Bold 1 index
  238.   /Helvetica-BoldOblique 1 index
  239.   /Times-Roman mark /Flags 16#22 .dicttomark
  240.   /Times-Bold 1 index
  241.   /Times-Italic mark /Flags 16#62 .dicttomark
  242.   /Times-BoldItalic 1 index
  243.   /Symbol mark /Flags 16#4 .dicttomark
  244.   /ZapfDingbats 1 index
  245. .dicttomark readonly def
  246.  
  247. % ---------------- Utilities ---------------- %
  248.  
  249. /.pdforigfontcache_g 20 dict def
  250. currentglobal false setglobal
  251. systemdict /.pdforigfontcache_l 20 dict .forceput
  252. setglobal
  253.  
  254. % Cache original fonts to prevent adjustfont to accumulate changes.
  255. /pdfcachefont {   % <font_name> pdfcachefont <font>
  256.   dup //.pdforigfontcache_g exch .knownget {
  257.     exch pop
  258.   } {
  259.     dup .pdforigfontcache_l exch .knownget {
  260.       exch pop
  261.     } {
  262.       dup findfont dup    
  263.       dup gcheck { //.pdforigfontcache_g } { .pdforigfontcache_l } ifelse
  264.                      % Stack : font_name font font cache
  265.       4 2 roll .growput
  266.     } ifelse
  267.   } ifelse
  268. } bind def
  269.  
  270. % Find a font (except for embedded ones), and adjust its encoding if necessary.
  271. /.pdfdfndict mark
  272.   /defaultfontname /Helvetica
  273. .dicttomark readonly def
  274. /pdffindfont {        % <font-resource> <fontname> pdffindfont <font>
  275.         % If the font isn't available, synthesize one based on
  276.         % its descriptor.
  277.   dup /Font resourcestatus {
  278.     pop pop pdfcachefont
  279.   } {
  280.     1 index /FontDescriptor knownoget {
  281.         % Stack: font-res fontname fontdesc
  282.       dup /Flags oget
  283.       dup 16#40 and -6 bitshift        % 1, oblique/italic
  284.       1 index 16#40000 and -17 bitshift add    % 2, bold
  285.       exch 16#2 and 2 bitshift add    % 8, serif
  286.         % We should look at the fixed flag, too.
  287.         % Stack: font-res fontname fontdesc properties
  288.  
  289.                 % Even though /FontName is a required key in FontDescriptor dict
  290.                 % (As of the PDF 1.4 Reference Manual), In the case of missing 
  291.                 % /FontName key, we substitue /BaseFont for the value of /FontName.
  292.                 % Yet another case of broken PDF's that Adobe Reader accepts.
  293.       1 index dup /FontName known {
  294.         /FontName oget exch
  295.       } {
  296.         (   **** FontDescriptor missing required /FontName key. BaseFont name used.\n)
  297.         pdfformaterror
  298.         pop 2 index exch    % grab the BaseFont from the stack.
  299.       } ifelse
  300.         % Analyzes font name and extract "Narrow" property
  301.         % which is not described by the FontDescriptor Flags.
  302.       0 2 index .fontnameproperties 4 and or
  303.         % Rebind the default font name to Helvetica so that
  304.         % fonts with no properties are handled correctly.
  305.       //.pdfdfndict begin .substitutefontname end
  306.         % Stack: font-res fontname fontdesc substname|null
  307.       Fontmap 1 index known not {
  308.         % No available good substitution, use the standard one.
  309.     pop 1 index .substitutefont
  310.       } if
  311.       dup 3 index ne QUIET not and {
  312.     (Substituting font ) print dup =only
  313.     ( for ) print 2 index =only (.) = flush
  314.       } if
  315.       pdfcachefont
  316.         % Stack: font-res fontname fontdesc font
  317.         % If this is a small-caps font, replace the CharString
  318.         % entries for a..z.
  319.       exch /Flags oget 16#20000 and 0 ne {
  320.     true .copyfontdict
  321.     dup /CharStrings 2 copy get dup length dict .copydict
  322.     4 index /FirstChar get 97 .max
  323.     5 index /LastChar get 122 .min 1 exch {
  324.         % Stack: font-res font' font' /CharStrings charstrings code
  325.         % Note that this only remaps a-z, not accented characters.
  326.       5 index /Widths oget 1 index 7 index /FirstChar get sub oget
  327.       1 string dup 0 5 -1 roll put
  328.         % Stack: font-res font' font' /CharStrings charstrings code
  329.         %   width (x)
  330.       2 index exch dup cvn exch
  331.       dup 0 2 copy get 32 sub put 4 -1 roll {
  332.             % Stack: operand (X) width
  333.         0 setcharwidth exch pop
  334.         currentfont /FontMatrix get matrix invertmatrix concat
  335.         0.7 dup scale 0 0 moveto show
  336.       } /exec cvx 4 packedarray cvx put
  337.     } for put
  338.       } if
  339.       dup /FontName get 2 index ne {
  340.         true .copyfontdict
  341.         2 copy exch /FontName exch put
  342.       } if
  343.       definefont
  344.     } {
  345.         % No descriptor available, use the default algorithm.
  346.       pdfcachefont
  347.     } ifelse
  348.   } ifelse
  349.   exch pop
  350. } bdef
  351.  
  352. % ---------------- Type 1 fonts ---------------- %
  353.  
  354. /buildType1        % <Type1-font-resource> buildType1 <font>
  355.  { dup /BaseFont get pdffindfont
  356.  } bdef
  357.  
  358. % The state dictionary for the embedded Type 1 font reading procedure
  359. % has the following keys and values:
  360. %    data - stream (filter)
  361. %    buffer, buffer2 - string
  362. %    hexify - procedure to convert buffer to hex if needed
  363. %    leftstr - string containing (non-negative) integer
  364. %    sectionstr - string containing a character 0 .. 3
  365. %    stream - (stream) dictionary
  366. %    proc - procedure of the form {-dict- type1read}
  367. %       pfbhdr - string containing 16#80 if PFB, 0 otherwise
  368. % When the procedure is executing, this dictionary is current.
  369. % leftstr and sectionstr are strings so that we can change their values
  370. % reliably in case the font executes a restore!
  371. % We also have to do something special about embedded fonts that
  372. % execute definefont more than once -- that is the function of topFontDict.
  373.  
  374. % Read an embedded Type 1 font.
  375. /readfontfilter {    % <proc> readfontfilter <filter>
  376.   0 () /SubFileDecode filter
  377. } bdef
  378. /readtype1dict 5 dict dup begin
  379.   /definefont {
  380.     dup topFontDict eq topFontDict null eq or {
  381.       dup wcheck not { dup length dict copy } if
  382.       exch pop savedFontName exch
  383.     } if
  384.     //systemdict /definefont get exec
  385.   } bdef
  386.   /eexec {
  387.     % Assume the font dictionary is directly below the file on the stack
  388.     count 0 gt { /topFontDict 2 index cvlit store } if
  389.     //.eexec_param_dict /eexecDecode filter
  390.     //systemdict begin readtype1dictcopy begin cvx stopped
  391.     currentdict readtype1dictcopy eq { end } if
  392.     currentdict //systemdict eq { end } if
  393.      { stop } if
  394.   } bdef
  395. end readonly def
  396. /readtype1 {        % <font-resource> <stream-dict> readtype1 <font>
  397.         % Read the definition, using a procedure-based filter
  398.         % that turns binary/hex conversion on and off
  399.         % at the right times.
  400.    1 index exch
  401.    PDFfile fileposition 3 1 roll
  402.    11 dict begin
  403.      /leftstr (          ) 10 string copy def
  404.        dup /Length1 oget leftstr cvs pop
  405.      /sectionstr <00> 1 string copy def
  406.      /pfbhdr <00> 1 string copy def
  407.      /stream 1 index def
  408.      true resolvestream /data exch def
  409.      /buffer 1000 string def        % arbitrary
  410.      /buffer2 buffer length 2.1 div cvi 1 sub string def
  411.      /hexify /buf2hex load def
  412.    currentdict end
  413.    /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
  414.    readfontfilter
  415.         % Some buggy embedded fonts leave extra junk on the stack,
  416.         % so we have to make a closure that records the stack depth
  417.         % in a fail-safe way.
  418.    //systemdict begin
  419.         % The PDF specification is somewhat muddy about whether
  420.         % an embedded font's name is supposed to be the BaseFont
  421.         % from the Font object or the FontName from the descriptor.
  422.         % Acrobat Distiller requires the former.  Save away the
  423.         % name so we can substitute it at definefont time.
  424.    //readtype1dict dup length 3 add dict copy begin
  425.    1 index /BaseFont oget /savedFontName exch def
  426.    /topFontDict null def
  427.    /readtype1dictcopy currentdict def
  428.     { run } aload pop count 1 sub 2 packedarray cvx exec
  429.    end end
  430.    count exch sub { pop } repeat
  431.    PDFfile 3 -1 roll setfileposition
  432.    /BaseFont oget findfont
  433.    exch pop
  434.  } bdef
  435.  
  436. % Execute the appropriate reading procedure.
  437. /type1read        % <dict> type1read <string>
  438.  { begin leftstr cvi
  439.     { type1read0 type1read1 type1read2 type1read3 } sectionstr 0 get get exec
  440.    (          ) leftstr copy cvs pop end
  441.  } bdef
  442.  
  443. % Read the next block of data into the buffer.
  444. /type1readdata        % <left> <buffer> type1readdata <substring> <left'>
  445.  { 0 2 index 2 index length .min getinterval
  446.         % Adobe requires readstring to signal an error if given
  447.         % an empty string.  Work around this nonsense here.
  448.    dup length 0 ne { data exch readstring pop } if
  449.    dup length 3 -1 roll exch sub
  450.    DEBUG
  451.     { dup =only ( read ) print
  452.       1 index length =only (: ) print
  453.       1 index == flush
  454.     } if
  455.  } bdef
  456.  
  457. % Read the initial byte to see if we need to skip a 6 byte PFB header
  458. /type1read0 {         % <left> type1read0 <string> <left'>
  459.   sectionstr 0 1 put    % either way we go to the next stage
  460.   pfbhdr type1readdata
  461.   1 index 0 get 16#80 eq {
  462.     (   **** Warning: Embedded Type1 font in PFB format is not valid PDF.\n)
  463.     pdfformaterror
  464.     DEBUG { (skipping PFB header) = flush } if
  465.     exch pop buffer 0 5 getinterval type1readdata exch
  466.     dup 4 get 256 mul 1 index 3 get add 256 mul
  467.     1 index 2 get add 256 mul 1 index 1 get add
  468.     DEBUG { (PFB segment length = ) print dup = } if
  469.     exch pop  % discard the string keeping the PFB segment length
  470.     2 copy ne {
  471.       (   **** Warning: Type 1 PFB segment length and Length 1 value do not match.\n)
  472.       pdfformaterror
  473.       exch     % keep the PFB length instead
  474.     } if
  475.     pop
  476.     buffer type1readdata    % go ahead and read a block
  477.   }
  478.   if    % if not PFB, return pfbhdr string (first char of file, usually %).
  479. } bdef
  480.  
  481. % Read the next block of the initial text portion.
  482. /type1read1 {        % <left> type1read1 <string> <left'>
  483.   DEBUG { (read1 ) print } if
  484.   dup 0 eq {
  485.     pop sectionstr 0 2 put
  486.     stream /Length2 oget
  487.             % Determine whether to hexify data for eexec.
  488.     dup 8 lt {
  489.       type1read2    % Hexify.
  490.     } {
  491.       DEBUG { (read2 ) print } if
  492.       pfbhdr 0 get 16#80 eq {
  493.         % eat 6 more bytes of PFB junk before proceeding
  494.     DEBUG { (skipping PFB header in segment 2) = flush } if
  495.     buffer 0 6 getinterval type1readdata exch
  496.         dup 5 get 256 mul 1 index 4 get add 256 mul
  497.     1 index 3 get add 256 mul 1 index 2 get add
  498.         DEBUG { (PFB segment length = ) print dup = } if
  499.     exch pop  % discard the string keeping the PFB segment length
  500.     2 copy ne {
  501.           (   **** Warning: Type 1 PFB segment length and Length 2 value do not match.\n)
  502.           pdfformaterror
  503.       exch         % keep the PFB length instead
  504.     } if
  505.       pop
  506.       } if
  507.       buffer2 type1readdata exch
  508.             % The check doesn't have to be 100% accurate:
  509.             % hexifying is always OK.
  510.       dup 0 8 getinterval 0 exch { or } forall
  511.       128 ge {
  512.     /hexify { } store
  513.     /buffer2 buffer def    % We don't need an intermediate buffer.
  514.       } if hexify exch
  515.     } ifelse
  516.   } {
  517.     buffer type1readdata
  518.   } ifelse
  519. } bdef
  520.  
  521. % Convert a string from binary to hex for eexec.
  522. % Free variables: buffer.
  523. /buf2hex {        % <string> buf2hex <hexstring>
  524.   buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
  525.   buffer (>) search pop exch pop exch pop
  526. } bdef
  527.  
  528. % Read the next block of the encrypted portion.
  529. /type1trailer
  530. (0000000000000000000000000000000000000000000000000000000000000000\n\
  531. 0000000000000000000000000000000000000000000000000000000000000000\n\
  532. 0000000000000000000000000000000000000000000000000000000000000000\n\
  533. 0000000000000000000000000000000000000000000000000000000000000000\n\
  534. 0000000000000000000000000000000000000000000000000000000000000000\n\
  535. 0000000000000000000000000000000000000000000000000000000000000000\n\
  536. 0000000000000000000000000000000000000000000000000000000000000000\n\
  537. 0000000000000000000000000000000000000000000000000000000000000000\n\
  538. cleartomark\n)
  539. readonly def
  540. /type1read2 {        % <left> type1read2 <string> <left'>
  541.   DEBUG { (read2 ) print } if
  542.    dup 0 eq
  543.     { pop sectionstr 0 3 put
  544.       stream /Length3 oget
  545.       dup 0 eq
  546.        { DEBUG { (trailer ) print } if
  547.      type1trailer exch
  548.        }
  549.        { 
  550.          pfbhdr 0 get 16#80 eq {
  551.            % eat 6 more bytes of PFB junk before proceeding
  552.        DEBUG { (skipping PFB header in segment 3) = flush } if
  553.        buffer 0 6 getinterval type1readdata exch
  554.            dup 5 get 256 mul 1 index 4 get add 256 mul
  555.        1 index 3 get add 256 mul 1 index 2 get add
  556.            DEBUG { (PFB segment length = ) print dup = } if
  557.        exch pop  % discard the string keeping the PFB segment length
  558.        2 copy ne {
  559.            (   **** Warning: Type 1 PFB segment length and Length 3 value do not match.\n)
  560.            pdfformaterror
  561.          exch     % keep the PFB length instead
  562.        } if
  563.        pop
  564.          } if
  565.          type1read3
  566.        }
  567.       ifelse
  568.     }
  569.     { buffer2 type1readdata exch hexify exch
  570.     }
  571.    ifelse
  572. } bdef
  573.  
  574. % Read the next block of the final text portion.
  575. % When finished, this procedure returns an empty string.
  576. /type1read3        % <left> type1read3 <string> <left'>
  577.  { DEBUG { (read3 ) print } if
  578.    buffer type1readdata
  579.  } bdef
  580.  
  581. % ---------------- Type 3 fonts ---------------- %
  582.  
  583. /buildType3 {        % <Type3-font-resource> buildType3 <font>
  584.   8 dict begin
  585.     /FontType 3 def
  586.     /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
  587.     /FontBBox 1 index /FontBBox get cvx def
  588.     /FontMatrix 1 index /FontMatrix oget def
  589.     /CharProcs 1 index /CharProcs oget def
  590.     1 index /Widths knownoget {
  591.       /Widths exch def
  592.       /FirstChar 1 index /FirstChar oget def
  593.       /LastChar 1 index /LastChar oget def
  594.     } if
  595.     /FontName 1 index /Name .knownget not { 
  596.        PDFfile fileposition 16 10 string cvrs cvn
  597.     } if def
  598.  
  599.     /Encoding .notdefEncoding 2 index getencoding def
  600.         % We have to define BuildChar rather than BuildGlyph:
  601.         % there is no PDF equivalent of glyphshow, and we need
  602.         % the character code to access the Widths.
  603.     /BuildChar {
  604.         % Stack: font charcode
  605.       1 index begin 3 dict begin
  606.       /Font 3 -1 roll def /CharCode 1 index def
  607.       % Make unknown characters map to /.notdef
  608.       Encoding exch get dup CharProcs exch known
  609.         { CharProcs exch oget }
  610.     { pop CharProcs /.notdef oget }
  611.       ifelse
  612.       PDFfile fileposition exch
  613.       false resolvestream
  614.         % Stack: filepos stream
  615.         % Don't let setgcolor set the color inside the BuildGlyph
  616.         % procedure, because this causes an /undefined error.
  617.       q null /FillColor gput null /StrokeColor gput
  618.       Font /Resources get exch pdfopdict .pdfruncontext
  619.       Q
  620.       PDFfile exch setfileposition
  621.       end end
  622.     } bdef
  623.     FontName currentdict end definefont exch pop
  624. } bdef
  625. /.adjustcharwidth {    % <wx> <wy> .adjustcharwidth <wx'> <wy'>
  626.   /Widths where {
  627.     begin
  628.     CharCode FirstChar ge CharCode LastChar le and {
  629.       exch pop Widths CharCode FirstChar sub get exch
  630.     } if end
  631.   } if
  632. } bdef
  633.  
  634. % ---------------- TrueType fonts ---------------- %
  635.  
  636. /TTfonts mark
  637.   /Arial /Helvetica
  638.   /Arial,Italic /Helvetica-Oblique
  639.   /Arial,Bold /Helvetica-Bold
  640.   /Arial,BoldItalic /Helvetica-BoldOblique
  641.   /CourierNew /Courier
  642.   /CourierNew,Bold /Courier-Bold
  643.   /TimesNewRoman /Times-Roman
  644.   /TimesNewRoman,Italic /Times-Italic
  645.   /TimesNewRoman,Bold /Times-Bold
  646.   /TimesNewRoman,BoldItalic /Times-BoldItalic
  647. .dicttomark readonly def
  648.  
  649. /buildTrueType {    % <TrueType-font-resource> buildTrueType <font>
  650.   dup /BaseFont oget
  651.   (   **** Warning: Fonts with Subtype = /TrueType should be embedded.\n) pdfformaterror
  652.   (                 But ) pdfformaterror dup =string cvs pdfformaterror ( is not embedded.\n) pdfformaterror
  653.   dup TTfonts exch .knownget {
  654.     QUIET not {
  655.       (Substituting font ) print dup =only
  656.       ( for ) print 1 index =only (.) = flush
  657.     } if
  658.     exch 3 1 roll pdffindfont
  659.     true .copyfontdict
  660.     2 copy exch /FontName exch put
  661.     definefont
  662.   } {
  663.     pdffindfont
  664.   } ifelse
  665. } bdef
  666.  
  667. % Read an embedded TrueType font.
  668. /readtruetype {        % <font-resource> <stream-dict> readtruetype <font>
  669.         % This is much simpler than readtype1, because we don't
  670.         % have to deal with the tripartite .PFB format.
  671.   1 index exch
  672.   PDFfile fileposition 3 1 roll
  673.   true resolvestream readfontfilter
  674.         % Stack: filepos fontres stream
  675.   1 index /Subtype get /CIDFontType2 eq {
  676.     .loadttcidfont
  677.         % Stack: filepos fontres cidfont
  678.     1 index /CIDToGIDMap knownoget {
  679.       dup /Identity eq {
  680.     pop
  681.       } {
  682.     true resolvestream
  683.         % Stack: filepos fontres font mapstream
  684.     dup 2 index /CIDCount oget dup 32767 le {
  685.           2 mul string readstring pop
  686.         } {
  687.       % Length exceeded max string size, use an array of two strings
  688.           % stack: filepos fontres font mapstream mapstream CIDCount
  689.           1 index 32767 string readstring not {
  690.             (   **** Warning: CIDToGIDMap length of ) pdfformaterror
  691.             dup length 2 div cvi =string cvs pdfformaterror
  692.             (, expected length of ) pdfformaterror
  693.             exch =string cvs pdfformaterror
  694.             (.\n) pdfformaterror
  695.             exch pop
  696.           } {
  697.         3 1 roll 32767 sub string readstring pop 
  698.         2 array astore
  699.           } ifelse
  700.         } ifelse
  701.     exch closefile exch dup length 5 add dict .copydict
  702.     dup /FID undef
  703.     dup /CIDMap 4 -1 roll put
  704.     dup /CIDFontName get exch /CIDFont defineresource
  705.       } ifelse
  706.     } if
  707.   } {
  708.     1 index /FontDescriptor oget /Flags get 4 and 0 ne % is_symbolic
  709.     .loadpdfttfont
  710.   } ifelse
  711.   exch pop
  712.   PDFfile 3 -1 roll setfileposition
  713.         % Ignore both the Encoding and the Widths.
  714.   exch pop
  715. } bdef
  716.  
  717. % ---------------- Type 0 fonts ---------------- %
  718.  
  719. % Predefine the known CMaps, but only create them on demand.
  720. /knownCMaps mark
  721.   /Identity-H { /Identity-H 0 makeIdentityCMap }
  722.   /Identity-V { /Identity-V 1 makeIdentityCMap }
  723. .dicttomark def
  724.  
  725. /makeIdentityCMap {        % <cmapname> <wmode> .makeIdentityCMap -
  726.   .currentglobal true .setglobal 3 1 roll
  727.   /CIDInit /ProcSet findresource begin
  728.   12 dict begin
  729.     begincmap
  730.     /WMode exch def
  731.     /CMapName exch def
  732.     /CIDSystemInfo 3 dict dup begin
  733.       /Registry (Adobe) def
  734.       /Ordering (Identity) def
  735.       /Supplement 0 def
  736.     end def
  737.     %/CMapName (see above)
  738.     /CMapVersion 1 def
  739.     /CMapType 1 def
  740.     %WMode (see above)
  741.     % The PDF documentation says that these CMaps map CIDs
  742.     % "1 to 65,536".  This is a misprint for 0 to 65,535.
  743.     1 begincodespacerange
  744.     % <0001> <00ff>  <0100> <ffff>
  745.       <0000> <ffff>
  746.     endcodespacerange
  747.     1 begincidrange
  748.     % <0001> <00ff> 1   <0100> <ffff> 256
  749.       <0000> <ffff> 0
  750.     endcidrange
  751.     endcmap
  752.     CMapName currentdict /CMap defineresource
  753.     knownCMaps CMapName 2 index put
  754.   end        % CMap
  755.   end        % CIDInit ProcSet
  756.   exch .setglobal
  757. } bdef
  758.  
  759. /buildType0 {        % <Type0-font-resource> buildType0 <font>
  760.   dup /BaseFont get    % FontName
  761.   1 index /Encoding oget
  762.   dup type /nametype eq {
  763.     dup /CMap resourcestatus {
  764.     pop pop /CMap findresource
  765.     } {
  766.     knownCMaps 1 index .knownget
  767.       { exch pop exec } { /undefined signalerror } ifelse
  768.     } ifelse
  769.   } {
  770.     PDFfile fileposition exch
  771.     dup /CMapName get exch true resolvestream cvx exec
  772.     /CMap findresource
  773.     exch PDFfile exch setfileposition
  774.   } ifelse        % CMap
  775.   [
  776.     3 index /DescendantFonts oget { exec resourcefont } forall
  777.   ]            % subfonts
  778.   composefont
  779.         % Stack: fontres font
  780.   1 index /FontMatrix knownoget {
  781.     dup aload pop true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
  782.       1 index exch makefont exch /FontName get exch definefont
  783.     } {
  784.       pop
  785.     } ifelse
  786.   } if exch pop
  787. } bdef
  788.  
  789. % ---------------- CIDFontType0/2 fonts ---------------- %
  790.  
  791. % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
  792. % arrays and using a (currently very inefficient) CDevProc.
  793. % For detail, refer "PDF Reference" 2nd ed., p314 "5.6.3 CIDFonts".
  794. % It notes default DW is 0, but Acrobat Reader uses 1000 as default.
  795. % If DW is 0, currentpoint does not move by default in rendering text
  796. % horizontally, the result is unreadable. You can check it by Acrobat.
  797.  
  798. /.pdfDefaultDW  1000 def
  799. /.pdfDefaultDW2 [ 880 -1000 ] def
  800.  
  801. /addCIDmetrics {    % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
  802.   dup length 5 add dict .copydict
  803.   dup /FID undef
  804.   dup /UniqueID undef
  805.   dup /XUID undef
  806.     % Insert the widths into the font.
  807.  
  808.         % Stack: pdfresource newfont
  809.  
  810.   1 index /DW .knownget {
  811.     1 index /DW 3 -1 roll put
  812.   } {
  813.     dup /DW .pdfDefaultDW put
  814.   } ifelse
  815.  
  816.   1 index /W .knownget {
  817.     dup 2 index /W 3 -1 roll put
  818.     .pdfMakeInternalW 1 index /.internalW 3 -1 roll put
  819.   } if
  820.  
  821.   1 index /DW2 .knownget {
  822.     1 index /DW2 3 -1 roll put
  823.   } {
  824.     dup /DW2 .pdfDefaultDW2 put
  825.   } ifelse
  826.  
  827.   1 index /W2 .knownget {
  828.     dup 2 index /W2 3 -1 roll put
  829.     .pdfMakeInternalW2 1 index /.internalW2 3 -1 roll put
  830.   } if
  831.  
  832.   dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  833.   exch pop
  834. } bdef
  835.  
  836. /.pdfMakeInternalMTXArray { % <mtx_array> <item_size> .pdfConvertInternalW <mtx_array'>
  837.  
  838.   % convert /W or /W2 to internal expression
  839.   %
  840.   %   mtx_array: original /W or /W2 array
  841.   %   item_size: number of metrics values per CID
  842.   %
  843.   %   for detail of the metrics list format in PDF,
  844.   %   refer PDF Ref. p.317 "Glyph Metrics in CIDFonts".
  845.   % 
  846.   %   format of single entry in internal expression
  847.   %
  848.   %     [
  849.   %       [cid_begin cid_end]
  850.   %       value_is_varied (bool)
  851.   %       [ [values for cid_begin...]
  852.   %         [values for cid_begin + 1]
  853.   %         ... ]
  854.   %     ]
  855.   %
  856.  
  857.   7 dict
  858.   begin
  859.     /itemSize exch def
  860.     /M exch def            % original /W or /W2
  861.     /Msize M length def
  862.     /Mi { M i get } def        % W[i]
  863.     /Mi1 { M i 1 add get } def    % W[i + 1]
  864.     /putMTXEntry <<
  865.       /arraytype   {
  866.          [
  867.            [Mi Mi Mi1 length add 1 sub]
  868.            true
  869.            [
  870.              0 itemSize Mi1 length 1 sub {
  871.                [ exch 1 1 index itemSize add 1 sub { Mi1 exch get } for ]
  872.              } for
  873.            ]
  874.          ]
  875.          /i i 2 add def
  876.       }
  877.       /integertype {
  878.          [
  879.            [Mi Mi1]
  880.            false
  881.            [[ i 2 add 1 i 1 add itemSize add { M exch get } for ]]
  882.          ]
  883.          /i i 3 add def
  884.       }
  885.     >> def
  886.  
  887.     /i 0 def
  888.  
  889.     [ { putMTXEntry Mi1 type get exec i Msize ge { exit } if } loop ]
  890.   end
  891. } def
  892.  
  893. /.pdfMakeInternalW  { dup length 0 gt { 1 .pdfMakeInternalMTXArray } if } def
  894. /.pdfMakeInternalW2 { dup length 0 gt { 3 .pdfMakeInternalMTXArray } if } def
  895.  
  896. /.pdfGetMTXByCID { % <internalMTXArray> <cid>
  897.                    %     .pdfGetMTXByCID
  898.                    %         { <MTXEntry> true | false }
  899.  
  900.   % get values for given CID from internal format of /W or /W2
  901.  
  902.   exch
  903.   {
  904.     {
  905.       dup 0 get {} forall      % Stack: <cid> <entry> <cid_0> <cid_1>
  906.       3 index lt { pop pop false exit } if
  907.       2 index exch sub dup 0 lt { pop pop false exit } if
  908.       1 index 1 get not { pop 0 } if
  909.       exch 2 get exch get true exit
  910.     } loop
  911.     { exit } if
  912.   } forall
  913.   dup type /arraytype eq { exch pop true } { pop false } ifelse
  914. } def
  915.  
  916.  
  917. % Apply the [D]W[2] metrics to a character before displaying.
  918. /CIDWProc {        % <w0x> <w0y> <llx> <lly> <urx> <ury>
  919.             %   <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
  920.             %   <w0x'> ... <vy'>
  921.  
  922.   begin % push <font> to currentdict
  923.     % <w1x> <w1y> <vx> <vy> won't be used and replaced, discard now
  924.     5 1 roll pop pop pop pop
  925.  
  926.     {
  927.       currentdict /DW .knownget not {   % no DW
  928.         .pdfDefaultDW exit              % replace <w0x> by defaultDW
  929.       } if
  930.  
  931.       currentdict /.internalW .knownget not {    % no W
  932.         exit                            % use already-stacked DW
  933.       } if
  934.  
  935.       dup length 0 eq {                 % W is null array
  936.         pop                             % discard unusable W
  937.         exit                            % use already-stacked DW
  938.       } if
  939.  
  940.       % W is finite array, try to get W_cid
  941.       2 index .pdfGetMTXByCID {           % got W, discard DW
  942.         exch pop {} forall
  943.         exit
  944.       } if
  945.  
  946.       exit
  947.     } loop
  948.  
  949.     1000 div                    % <w0x'> (normalized W)
  950.     0                           % <w0y'>
  951.  
  952.     % Stack: <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <w0x'> <w0y'>
  953.     9 -2 roll pop pop           % discard <w0x> <w0y>
  954.     7  2 roll                   % put <w0x'> <w0y'>
  955.  
  956.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <cid>
  957.     0                           % <w1x'>
  958.     exch                        % put <w1x'>
  959.  
  960.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <cid>
  961.     {
  962.       currentdict /DW2 .knownget not {  % no DW2, use defaultDW2
  963.         .pdfDefaultDW2 exit
  964.       } if
  965.  
  966.       currentdict /.internalW2 .knownget not {   % has DW2, no W2
  967.         exit                            % use already-stacked DW2
  968.       } if
  969.  
  970.       dup length 0 eq {                 % W2 is null array
  971.         pop                             % discard unusable W2
  972.         exit                            % use already-stacked DW2
  973.       } if
  974.  
  975.       2 index .pdfGetMTXByCID {        % got W2_cid, discard DW2
  976.         exch pop
  977.         exit
  978.       } if
  979.  
  980.       % could not get W2_cid
  981.       exit
  982.  
  983.     } loop
  984.  
  985.     exch pop                            % discard <cid>
  986.  
  987.  
  988.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> { [<vy'> <w1y'>] | [<w1y'> <vx'> <vy'>] }
  989.     dup length 2 eq {                   % this is DW2
  990.       {1000 div} forall exch
  991.       4 index 7 index add 2 div         % <vx'> = (<urx> + <llx>) / 2
  992.       exch
  993.     }{                                  % assume W2
  994.       {1000 div} forall
  995.     } ifelse
  996.   end                                   % recover currentdict
  997.  
  998. } def
  999.  
  1000. % <string> <match> tailmatch ==> <pre> true
  1001. %                            ==> <string> false
  1002. /tailmatch {
  1003.   2 copy length 1 index length .min
  1004.   dup 2 index length exch sub exch getinterval
  1005.   1 index eq {
  1006.     length 1 index length exch sub
  1007.     0 exch getinterval true
  1008.   } {
  1009.     pop false
  1010.   } ifelse
  1011. } bind def
  1012.  
  1013. /makeboldfont {
  1014.   16 dict begin
  1015.     /strokewidth exch def
  1016.     /basecidfont exch def
  1017.     /FontMatrix [ 1 0 0 1 0 0 ] def
  1018.  
  1019.     /CIDFontName /.boldfont def
  1020.     /CIDFontType 1 def
  1021.  
  1022.     /basefont-H /.basefont-H /Identity-H [ basecidfont ] composefont def
  1023.     /basefont-V /.basefont-V /Identity-V [ basecidfont ] composefont def
  1024.  
  1025.     /CIDSystemInfo dup basecidfont exch get def
  1026.     /FontBBox [ basecidfont /FontBBox get cvx exec
  1027.       4 2 roll basecidfont /FontMatrix get transform
  1028.       4 2 roll basecidfont /FontMatrix get transform
  1029.     ] def
  1030.  
  1031.     /tmpstr 2 string def
  1032.     /BuildGlyph {
  1033.       gsave
  1034.       exch begin
  1035.         dup 256 idiv tmpstr exch 0 exch put
  1036.         256 mod tmpstr exch 1 exch put
  1037.         rootfont /WMode known { rootfont /WMode get 1 eq } { false } ifelse
  1038.         { basefont-V } { basefont-H } ifelse setfont
  1039.         strokewidth setlinewidth
  1040.         1 setlinejoin
  1041.         newpath
  1042.         0 0 moveto tmpstr false charpath stroke
  1043.         0 0 moveto tmpstr show
  1044.         currentpoint setcharwidth
  1045.       end
  1046.       grestore
  1047.     } bind def
  1048.  
  1049.    currentdict
  1050.   end
  1051.   dup /CIDFontName get exch /CIDFont defineresource
  1052. } bind def
  1053.  
  1054. % <CIDFont-resource> <CIDFontName> findCIDFont <CIDFont-resource> <font>
  1055. %   CIDFont-resource is not modified.
  1056. /findCIDFont {
  1057.   {
  1058.     dup /CIDFont resourcestatus {
  1059.       pop pop /CIDFont findresource
  1060.       exit
  1061.     } if
  1062.  
  1063.     dup dup length string cvs
  1064.     (,Bold) tailmatch {
  1065.       exch pop
  1066.       cvn findCIDFont 0.03 makeboldfont
  1067.       exit
  1068.     } if
  1069.     (,Italic) tailmatch {
  1070.       exch pop
  1071.       cvn findCIDFont
  1072.       [ 1 0 0.3 1 0 0 ] makefont
  1073.       exit
  1074.     } if
  1075.     (,BoldItalic) tailmatch {
  1076.       exch pop
  1077.       cvn findCIDFont 0.03 makeboldfont
  1078.       [ 1 0 0.3 1 0 0 ] makefont
  1079.       exit
  1080.     } if
  1081.     pop
  1082.  
  1083.     1 index /CIDSystemInfo get begin Registry (-) Ordering end
  1084.     concatstrings concatstrings
  1085.     cvn
  1086.     QUIET not {
  1087.       (Substituting ) print dup ==only
  1088.       ( for ) print 1 index ==only (.\n) print
  1089.     } if
  1090.     exch pop
  1091.     /CIDFont findresource
  1092.     exit
  1093.   } loop
  1094. } bdef
  1095.  
  1096. /buildCIDType0 {    % <CIDFontType0-font-resource> buildCIDType0 <font>
  1097.   dup /BaseFont get exch 1 index findCIDFont
  1098.   addCIDmetrics /CIDFont defineresource
  1099. } bdef
  1100.  
  1101. /buildCIDType2 {    % <CIDFontType2-font-resource> buildCIDType2 <font>
  1102.   dup /BaseFont get exch 1 index findCIDFont
  1103.   addCIDmetrics /CIDFont defineresource
  1104. } bdef
  1105.  
  1106. % ---------------- Other embedded fonts ---------------- %
  1107.  
  1108. /fontloadprocs mark
  1109.   /Type1C /readType1C cvx
  1110.   /CIDFontType0C /readCIDFontType0C cvx
  1111. .dicttomark readonly def
  1112.  
  1113. % Read an embedded compressed font.
  1114. /readType1C {        % <font-resource> <stream-dict> readType1C <font>
  1115.   1 index exch
  1116.   PDFfile fileposition 3 1 roll
  1117.   dup true resolvestream dup readfontfilter
  1118.         % Stack: pos resource streamdict stream filter
  1119.   3 index /FontDescriptor oget /FontName oget
  1120.   1 index FRD
  1121.   closefile closefile pop
  1122.   PDFfile 3 -1 roll setfileposition
  1123.   /FontDescriptor oget /FontName oget findfont
  1124.   exch pop
  1125. } bdef
  1126.  
  1127. % Read an embedded CFF CIDFont.
  1128. /readCIDFontType0C {  % <font-resource> <stream-dict> readCIDFontType0C <font>
  1129.   PDFfile fileposition 3 1 roll
  1130.   dup true resolvestream dup readfontfilter
  1131.         % Stack: pos resource streamdict stream filter
  1132.   3 index /FontDescriptor oget /FontName oget
  1133.   1 index FRD
  1134.   closefile closefile pop
  1135.   PDFfile 3 -1 roll setfileposition
  1136.         % Some broken Adobe software produces PDF files in which
  1137.         % the FontName of the CFF font and the FontName in the
  1138.         % FontDescriptor don't match the BaseFont in the font.
  1139.         % Use the FontName, rather than the BaseFont, here.
  1140.   dup /FontDescriptor oget /FontName oget /CIDFont findresource
  1141.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  1142. } bdef
  1143.  
  1144. % ---------------- Font lookup ---------------- %
  1145.  
  1146. /fonttypeprocs mark        % <font-resource> -proc- <font>
  1147.   /Type0 /buildType0 cvx
  1148.   /Type1 /buildType1 cvx
  1149.   /MMType1 1 index
  1150.   /Type3 /buildType3 cvx
  1151.   /TrueType /buildTrueType cvx
  1152.   /CIDFontType0 /buildCIDType0 cvx
  1153.   /CIDFontType2 /buildCIDType2 cvx
  1154. .dicttomark readonly def
  1155.  
  1156. /adjustfonttypes mark
  1157.   /Type1 true
  1158.   /MMType1 true
  1159.   /TrueType true
  1160. .dicttomark readonly def
  1161.  
  1162. /resourcefont            % <font-resource> resourcefont <font>
  1163. { dup /PSFont .knownget
  1164.   { /FID knownoget { type /fonttype eq } { //false } ifelse }
  1165.   { //false }
  1166.   ifelse
  1167.   { /PSFont get }
  1168.   { dup dup /FontDescriptor knownoget {    % Stack: font-res font-res font-desc
  1169.       dup /FontObject .knownget {
  1170.     3 1 roll pop pop
  1171.       } {
  1172.     dup /FontFile knownoget
  1173.     { exch pop readtype1 }
  1174.     { dup /FontFile2 knownoget
  1175.       { exch pop readtruetype }
  1176.       { /FontFile3 knownoget
  1177.         { dup /Subtype get fontloadprocs exch get exec }
  1178.             { dup /Subtype get fonttypeprocs exch get exec }
  1179.         ifelse
  1180.       }
  1181.       ifelse
  1182.     }
  1183.     ifelse
  1184.     1 index /FontDescriptor oget
  1185.     1 index /FontObject exch put        % Save pointer to the font
  1186.       }
  1187.       ifelse
  1188.     }
  1189.     { dup /Subtype get fonttypeprocs exch get exec }
  1190.     ifelse
  1191.     % Stack: font-res font
  1192.     1 index 3 1 roll
  1193.     1 index /Subtype get
  1194.     //adjustfonttypes exch known { adjustfont } { exch pop } ifelse
  1195.     dup 3 1 roll /PSFont exch put
  1196.   }
  1197.   ifelse
  1198. } bdef
  1199.  
  1200. drawopdict begin
  1201.   /d0 {
  1202.     .adjustcharwidth setcharwidth
  1203.   } bdef
  1204.   /d1 {
  1205.     4 index 0 ne {
  1206.       % invalid wy parameter for d1 in Type3 font (must be 0)
  1207.       % Even though the PDF 1.4 specification states that this must be 0,
  1208.       % Distiller sometimes creates Type3 fonts with non-zero wy. We set
  1209.       % it to 0 since this is apparently what Acrobat Reader 4 and 5 do,
  1210.       % but if the specification is ever changed to allow non-zero wy, this
  1211.       % will not work.
  1212.       5 -1 roll pop 0 5 1 roll    % set wy to 0
  1213.     } if
  1214.     6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
  1215.   } bdef
  1216.   /Tf {
  1217.     1 index Page /Font rget not { 1 index /invalidfont signalerror } if
  1218.     resourcefont exch Tf pop
  1219.   } bdef
  1220. end
  1221.  
  1222. end            % pdfdict
  1223. end            % GS_PDF_ProcSet
  1224. .setglobal
  1225.